#include "Camp.hpp"

using namespace std;
using namespace sf;

Camp::Camp() : nbTerr(0)
{
    //ctor
    Camp::Couleurs[0] = sf::Color( 120, 0, 0 ); // rouge
    Camp::Couleurs[1] = sf::Color( 18, 27, 148 ); // bleu
    Camp::Couleurs[2] = sf::Color( 0, 120, 0 ); // vert
    Camp::Couleurs[3] = sf::Color( 238, 110, 13); // orange
    Camp::Couleurs[4] = sf::Color( 79, 12, 120 ); // violet
    Camp::Couleurs[5] = sf::Color( 230, 180, 20 ); // jaune
    Camp::Couleurs[6] = sf::Color( 70, 210, 190 ); // cyan
    Camp::Couleurs[7] = sf::Color( 250, 120, 180 ); // rose
}

void Camp::setIndice(int indice)
{
    this->indice=indice;
}

int Camp::getIndice() const
{
    return indice;
}

void Camp::setNbTerr(int nbTerr)
{
    this->nbTerr=nbTerr;
}

int Camp::getNbTerr() const
{
    return nbTerr;
}

void Camp::setEtat(Etat e)
{
    this->etat=e;
}

Etat Camp::getEtat() const
{
    return etat;
}
/*
void Camp::setCouleur(Couleur c)
{
    couleur=c;
}

Couleur Camp::getCouleur() const
{
    return couleur;
}
*/
int Camp::nbDesADeploi(int nbterrcarte,Territoire** terri) const
{
    return nbMaxTerritoireAdjacent(nbterrcarte,terri);
}

int Camp::nbTerritoire() const
{
    return territoires.size();
}

int Camp::nbMaxTerritoireAdjacent(int nbterrcarte,Territoire** terri) const
{
    int n=nbterrcarte;
    vector<int> recupvoisins;
    bool dejavu[n];
    bool dejavuterr[n];
    queue<Territoire *> file;
    int nbmaxTadj=1;
    int nb;
    Territoire* tcurrent;

    for(int i=0; i<n; i++)
    {
        dejavu[i]=false;
        dejavuterr[i]=false;
    }
    for(int j=0; j<territoires.size(); j++)
    {
        nb=1;
        for(int k=0; k<n; k++)
        {
            dejavu[k]=false;
        }
        if(!(dejavuterr[territoires[j]->getIndice()]))
        {
            file.push(territoires[j]);
            dejavuterr[territoires[j]->getIndice()]=true;
            dejavu[territoires[j]->getIndice()]=true;
            while(!file.empty())
            {
                tcurrent=file.front();
                file.pop();
                recupvoisins=tcurrent->getVoisins();
                for(int i(0); i<recupvoisins.size(); i++)
                {
                    if(!(dejavu[recupvoisins[i]])&&(this->indice==((terri[recupvoisins[i]])->getIndiceCamp())))
                    {
                        file.push(terri[recupvoisins[i]]);
                        dejavu[recupvoisins[i]]=true;
                        dejavuterr[recupvoisins[i]]=true;
                        nb++;
                    }
                }
            }
        }
        nbmaxTadj=max(nbmaxTadj,nb);
    }
    return nbmaxTadj;
}

bool Camp::enVie() const
{
    return (nbTerr>0);
}

bool Camp::appartient(Territoire* T) const
{
    return (T->getIndiceCamp() == this->indice);
}

void Camp::changerEtat()
{
    if(etat == eSPECTATEUR)
    {
        etat = eDEPLOIEMENT;
    }
    else if(etat == eDEPLOIEMENT)
    {
        etat = eCOMBAT;
    }
    else if(etat == eCOMBAT)
    {
        etat = eDEPLACEMENT;
    }
    else if(etat == eDEPLACEMENT)
    {
        etat = eSPECTATEUR;
    }
}

void Camp::ajouterTerritoire(Territoire* T)
{
    if(!(this->appartient(T)))
    {
        territoires.push_back(T);
        nbTerr++;
        T->setIndiceCamp(indice);
    }
    else
    {
        // Le Territoire est déjà dans le camp
    }
}

void Camp::retirerTerritoire(Territoire* T)
{
    int i=0;
    if(this->appartient(T))
    {
        while(territoires[i]!=T)
        {
            i++;
        }
        territoires.erase(territoires.begin()+i);
        nbTerr--;
    }
}

/*
void Camp::setColor(const Color& couleur)
{
    this->couleur=couleur;
}

const Color& Camp::getColor() const
{
    return couleur;
}
*/

Camp::~Camp()
{
    //dtor
}






sf::Color* Camp::Couleurs = new sf::Color[8];
